package com.browsesoft.resource;

import java.util.*;
import java.util.Map.Entry;

import org.json.JSONArray;
import org.json.JSONObject;

import com.browsesoft.EntityManager;
import com.browsesoft.ManagerGroup;
import com.browsesoft.Tools;
import com.browsesoft.user.Role;
import com.browsesoft.user.User;

public class ResourcePlugin {

	// 获得给定资源组成的子树
	// return - 有可能返回多个子树
	public JSONArray getFullTree(Iterable resources) {
		// 把未补全的存放起来
		List<Resource> sources = new ArrayList<Resource>();

		// 存放已经处理过的所有资源，在这里的资源，不再重复处理
		List<Resource> procs = new LinkedList<Resource>();

		// 对于要处理的每一个资源
		for (Object obj : resources) {
			Resource res = (Resource) obj;
			sources.add(res);
			// 循环找父节点
			while (res != null && !procs.contains(res)) {
				procs.add(res);
				res = res.getParent();
			}
		}

		// 从根节点开始，在上述保存的资源表里，递归获取子资源
		Resource root = EntityManager.getInstance().getRoot();
		JSONObject json = this.toJSON(root);
		// 设置根的全路径名
		json.put("fullname", json.getString("name"));
		json.put("fullid", json.getString("id"));
		procs.remove(root);
		this.addChild(json, root, procs, sources);

		JSONArray result = new JSONArray();
		result.put(json);

		return result;
	}

	// 获得给定资源的子
	// return - 有可能返回多个子树
	public JSONArray getChildren(String resId) {
		JSONArray result = new JSONArray();
		Resource res = (Resource) EntityManager.getInstance().getObject(resId);
		Iterator iter = res.getChildren();
		while (iter.hasNext()) {
			Resource childRes = (Resource) iter.next();
			JSONObject childJson = this.toJSON(childRes);
			result.put(childJson);
		}
		return result;
	}
	
	//根据资源名称获取资源，得到其所有子，没有返回空
	public JSONArray getChildrenOfResName(String resName) {
		JSONArray result = new JSONArray();
		Resource res = (Resource) EntityManager.getInstance().getResourceFromName(resName);
		// 没找到这种类型资源，返回空
		if(res == null) {
			return result;
		}

		Iterator iter = res.getChildren();
		while (iter.hasNext()) {
			Resource childRes = (Resource) iter.next();
			JSONObject childJson = this.toJSON(childRes);
			result.put(childJson);
		}
		return result;
	}

	/**
	 * 获取当前用户有权限的所有资源
	 *
	 */
	public JSONObject getRight(User user, String name) throws Exception {
		user.getRights();
		java.util.Collection resources = this.getRes(user);
		java.util.Collection notResources = ResourceTool
				.getAllAncenstor(resources);
		LinkedList<Resource> allResources = new LinkedList<Resource>();
		LinkedList<Resource> limitResources = new LinkedList<Resource>();
		limitResources.addAll(resources);
		allResources.addAll(resources);
		allResources.addAll(notResources);
		EntityManager entitymanager = (EntityManager) ManagerGroup
				.getManagerGroup().getManager("entity");
		Resource root = entitymanager.getRoot();
		JSONObject rootJson = this.toJSON(root);
		this.ergodic(rootJson, root, allResources,limitResources);
		// 遍历转换成数组
		return rootJson;
	}

	public boolean isInResource(Resource Res,LinkedList<Resource> limitResources) {
		Boolean flag=false;
		for (int i = 0; i < limitResources.size(); i++) {   
			if(Res.getAttributes().get("id")==limitResources.get(i).getAttributes().get("id")){
				flag=true;
			}
	    }
		return flag;
	}
	
	// 处理一个功能项，把子添加到自己的属性子中，并且把所有子删除掉，要递归调用
	public void ergodic(JSONObject parent, Resource res,
			LinkedList<Resource> allresources,LinkedList<Resource> limitResources) {
		LinkedList<Resource> children = Tools.iteratorToList(((Resource) res)
				.getChildren());
		// 从子中过虑掉无权访问的节点
		children.retainAll(allresources);
		children=this.checkLinkedList(children, allresources);
		JSONArray array = new JSONArray();
		for (Resource childRes : children) {
			//获取id串
			String idstr=new String();
			JSONObject child = this.toJSON(childRes);
			if(parent.has("powerid")){
				idstr=parent.getString("powerid")+'.'+child.getString("id"); 
			}else{
				idstr=parent.getString("id")+'.'+child.getString("id");
				//去除根部
				idstr=idstr.substring(idstr.indexOf(".")+1);
			}
			// 把子放置到父节点中
			// 如果有权限把他加入到
			child.put("powerid", idstr);
			if(!isInResource(childRes,limitResources)){
				child.put("power", "null");
			}
			if(isInResource(childRes,limitResources)){
				child.put("power", "manage");
			}
			array.put(child);
			ergodic(child, childRes, allresources,limitResources);
		}
		if (array.length() > 0) {
			parent.put("children", array);
		}
	}

	/**
	 * 检查过滤某些组织
	 * @param res
	 * @param allresources
	 * @return
	 */
	public static LinkedList checkLinkedList(LinkedList<Resource> res,LinkedList<Resource> allresources) {
		// 对迭代中的每一个对象，放到结果链表中
		LinkedList result = new LinkedList();
		for (Resource childRes : res) {
			if(childRes.getAttributes().get("name").equals("组织机构")){
				LinkedList<Resource> children = Tools.iteratorToList(((Resource) childRes)
						.getChildren());
				for (Resource checkres : children) {
					result.add(checkres);
				}
			}
			else{
				result.add(childRes);
			}
		}
		return result;
	}

	/**
	 * 得到资源
	 *
	 * @return 资源
	 * @throws Exception
	 */
	public java.util.Collection getRes(User user) throws Exception {
		java.util.Collection rs = LicensePolicyTool.getRights(user);
		LinkedList link = ((BasicResource) EntityManager.getInstance()
				.getRoot()).getSpecialResByType("role");
		Iterator iter = link.iterator();
		while (iter.hasNext()) {
			Role role = (Role) iter.next();
			LinkedList list = role.getUsers();
			if (list.contains(user)) {
				rs.addAll(LicensePolicyTool.getRights(role));
			}
		}
		return rs;
	}

	// 递归给父节点添加子节点
	// result - 返回的父节点
	// parent - 父节点
	// procs - 从这里找父节点的子
	// sources - 这里存放的是原始的，不包括自动补全的节点
	private void addChild(JSONObject result, Resource parent,
			List<Resource> procs, List<Resource> sources) {
		JSONArray array = new JSONArray();

		// 如果本节点在原始列表中，添加hasright属性
		if (sources.contains(parent)) {
			result.put("hasright", "true");
		}

		// 获取子节点，把子节点添加到父节点中
		List<Resource> reses = this.getChildren(parent, procs);
		procs.removeAll(reses);

		// 获取父节点的全路径名
		String parentName = (String) result.get("fullname");
		String parentId = (String) result.get("fullid");
		
		for (Resource res : reses) {
			JSONObject child = this.toJSON(res);
			// 设置子节点的全路径名
			child.put("fullname", parentName + "." + child.getString("name"));
			child.put("fullid", parentId + "." + child.getString("id"));

			// 把子放置到父节点中
			array.put(child);
			// 继续处理子节点
			this.addChild(child, res, procs, sources);
		}

		result.put("children", array);
	}

	// 把资源内容转换成JSON对象
	public static JSONObject toJSON(Resource res) {
		JSONObject result = new JSONObject();

		// 对于资源的每一个属性，转换成JSON格式
		Hashtable ht = res.getAttributes();
		for (Object o : ht.entrySet()) {
			Entry entry = (Entry) o;
			result.put(entry.getKey().toString(), entry.getValue());
		}

		return result;
	}

	// 在资源列表里，获取子资源
	private List<Resource> getChildren(Resource parent, List<Resource> list) {
		List<Resource> result = new LinkedList<Resource>();

		Iterator iter = parent.getChildren();
		while (iter.hasNext()) {
			Resource res = (Resource) iter.next();
			if (list.contains(res)) {
				result.add(res);
			}
		}

		return result;
	}

	/**
	 * 把迭代转换成列表
	 * @param iter
	 * @return
	 */
		public List toList(Iterator iter) {
			List result = new ArrayList();
			Iterator it = (Iterator) iter;
			JSONArray array = new JSONArray();
			while (it.hasNext()) {
				Object o = it.next();
				result.add(o);
			}
			return result;
		}

	/**
	 *  根据资源id号获取资源
	 * @param id
	 * @return
	 */
	public Resource getResource(String id) {
		Resource result = (Resource)EntityManager.getInstance().getObject(id);
		return result;
	}
}
